﻿//
//  Copyright (c) 2009 Liang Quan Qing.
//  All rights reserved.
// 
//  Redistribution and use in source and binary forms, with or without
//  modification, are permitted provided that the following conditions
//  are met:
//  1. Redistributions of source code must retain the above copyright
//     notice, this list of conditions and the following disclaimer.
//  2. Redistributions in binary form must reproduce the above copyright
//     notice, this list of conditions and the following disclaimer in the
//     documentation and/or other materials provided with the distribution.
// 
//  THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
//  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
//  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
//  ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
//  FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
//  DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
//  OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
//  HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
//  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
//  OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
//  SUCH DAMAGE.
//

#include <stddef.h>
#include "fastconv.h"
#include "fcnv_config.h"
#include "fcnvlocal.h"

size_t  wstrlen(const WChar_t *s)
{
    const   WChar_t *p = s;
    while( *p++ )   ;
    return( (size_t) (p-s-1) );
}

size_t  dstrlen(const DChar_t *s)
{
    const   DChar_t *p = s;
    while( *p++ )   ;
    return( (size_t) (p-s-1) );
}

size_t  fcnv_UTF32Length(const DChar_t * utf32str)                  //in DChars
{
    const   DChar_t *p = utf32str;
    while( *p++ )   ;
    return( (size_t) (p-utf32str-1) );
}

size_t  fcnv_UTF16Length(const WChar_t * utf16str)                  //in DChars
{
    const   WChar_t *p = utf16str;
    while( *p++ )   ;
    return( (size_t) (p-utf16str-1) );
}

size_t  fcnv_UTF8LengthFromUTF16 (const WChar_t * utf16str)          //in bytes
{
    size_t wcount;
    size_t bcount;
    int valid;
    DChar_t dch;

    for ( wcount = 0, bcount = 0 ; utf16str[wcount]; )
    {
        if ( ! isSurrogate(utf16str[wcount]) )     // if is normal UTF-16 character, not surrogate
        {
            bcount += GetU8CharSizeFromU32Char(utf16str[wcount]);
            wcount ++;
        }
        else
        {
            dch = MixSurrogate(utf16str[wcount], utf16str[wcount+1], &valid);
            if ( valid ) {
                bcount += GetU8CharSizeFromU32Char(dch);
                wcount += 2;
            }
            else {
                bcount += GetU8CharSizeFromU32Char(utf16str[wcount]);
                wcount ++;
            }
        }
    }
    return bcount;
}

size_t  fcnv_UTF8LengthFromUTF32 (const DChar_t * utf32str)          //in bytes
{
    size_t dcount;
    size_t bcount;
    int valid;
    DChar_t dch;

    for ( dcount = 0, bcount = 0 ; utf32str[dcount]; dcount ++ )
    {
        bcount += GetU8CharSizeFromU32Char(utf32str[dcount]);
    }
    return bcount;
}

size_t  fcnv_UTF16LengthFromUTF8 (const char    * utf8str)           //in WChars
{
    return 0;
}
size_t  fcnv_UTF16LengthFromUTF32(const DChar_t * utf32str)          //in WChars
{
    return 0;
}
size_t  fcnv_UTF32LengthFromUTF8 (const char    * utf8str)           //in DChars
{
    return 0;
}
size_t  fcnv_UTF32LengthFromUTF16(const WChar_t * utf16str)          //in DChars
{
    return 0;
}







